home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / ada / bd3.zip / PRINT.ME < prev    next >
Text File  |  1989-04-30  |  74KB  |  1,696 lines

  1.  
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15.                                               BANK DEMO 3BANK DEMO 3
  16.  
  17.                                    A Demonstration of Tasking in AdaA Demonstration of Tasking in Ada
  18.  
  19.  
  20.  
  21.  
  22.                                       Version 1.0, 11 March 1989
  23.  
  24.                                                   by
  25.                                              Richard Conn
  26.  
  27.  
  28.  
  29.  
  30.  
  31.                  Bank  Demo 3, or BD3 as the files and mainline procedure are named, is  a
  32.             demonstration program which illustrates how  Ada and its tasking mechanism can
  33.             be used to create a model of an activity in the real world.  BD3 is a model of
  34.             a bank, where the bank contains several tellers, implemented as Ada tasks, and
  35.             is used by  customers, also implemented as Ada tasks.  The user at the console
  36.             can monitor the status of the bank and the accounts of its customers and cause
  37.             more customer tasks to execute, thereby increasing the level  of  activity  at
  38.             the bank. The tasks all operate in parallel,  so  a  variety  of events can be
  39.             thought of as happening at the same time, controlled by the Ada runtime system
  40.             which is built into the Ada program by the Ada compilation system.
  41.  
  42.                  This  document  and  the   associated   software   are  presented  as  an
  43.             introduction  to the Ada language and its tasking  capabilities.    While  the
  44.             author attempted to make this  document  as  easy  to  follow  as  possible, a
  45.             limited knowledge of Ada is  assumed.  Variable assignments, type definitions,
  46.             and procedure and package specifications are presented in  correct  Ada syntax
  47.             without much explanation.  If  this  proves  to  be  a  problem,  the ADA-TUTR
  48.             shareware program will help a  lot  in  bringing  the  user up to date with an
  49.             understanding of Ada syntax.  Regardless, the program in the file  BD3.EXE can
  50.             be  run without any knowledge of Ada at all, and the tasking demonstration can
  51.             be observed.
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.                                               BANK DEMO 3
  59.                                    A Demonstration of Tasking in Ada
  60.  
  61.                                             by Richard Conn
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68.             1  Introduction            1  Introduction
  69.  
  70.  
  71.                  BD3 is a model of a bank.   The  Ada  package  called BANK represents the
  72.             bank  itself, and the bank contains four tellers,  represented  by  an  array,
  73.             named  TELLER, of four tasks.  BD3 is written in an object-oriented fashion in
  74.             the Ada programming language.
  75.  
  76.                 ======================================================================
  77.  
  78.               ADD_NEW_CUSTOMER
  79.                 -- to create a new account for a customer and return
  80.                 -- an ID for that customer
  81.               GET_BALANCE
  82.                 -- to return the balance of a customer's account
  83.               MAKE_DEPOSIT
  84.                 -- to deposit money into a customer's account
  85.               MAKE_WITHDRAWAL
  86.                 -- to withdraw money from a customer's account
  87.  
  88.                   Figure 1: The bank tellers can process four kinds of transactions.                  Figure 1
  89.  
  90.                 ======================================================================
  91.  
  92.                  Each  task,  TELLER(1)  to TELLER(4), supports one  entry  point,  called
  93.             REQUEST, which is used by tasks outside the BANK package to communicate with a
  94.             TELLER(n)  task  and  request  a  transaction.  Four transaction requests  are
  95.             recognized by a TELLER(n) task, as shown in Figure 1.
  96.  
  97.  
  98.                                 BD3 - A Demonstration of Tasking in Ada
  99.  
  100.  
  101.  
  102.                 ======================================================================
  103.  
  104.               MY_ID : BANK.CUSTOMER_ID;
  105.                 -- MY_ID is a variable which holds the customer ID of
  106.                 -- this task (type CUSTOMER_ID is defined in the package BANK)
  107.               AMOUNT : BANK.DOLLAR;
  108.                 -- type DOLLAR represents the unit of currency, as defined
  109.                 -- by the package BANK, and the variable AMOUNT is used to
  110.                 -- hold the money passed in to or out of the TELLER(n) task
  111.                  ...
  112.               BANK.TELLER(1).REQUEST (MY_ID, BANK.ADD_NEW_CUSTOMER, AMOUNT);
  113.                 -- this calls the REQUEST entry point for the task TELLER(1)
  114.                 -- in the package BANK; the ID of the customer is passed
  115.                 -- out of the TELLER(1) task in the variable MY_ID and the
  116.                 -- requested transaction is ADD_NEW_CUSTOMER, which is
  117.                 -- defined in the package BANK; the variable AMOUNT is
  118.                 -- passed as a parameter but not used
  119.               AMOUNT := 100.00;
  120.               BANK.TELLER(2).REQUEST (MY_ID, BANK.MAKE_DEPOSIT, AMOUNT);
  121.                 -- the variable AMOUNT is set to $100, and the REQUEST
  122.                 -- entry point of TELLER(2) in the package BANK is
  123.                 -- called; the variable MY_ID, which was set by the call
  124.                 -- to TELLER(1) above, is used to identify the customer,
  125.                 -- and the requested action is MAKE_DEPOSIT, as defined by
  126.                 -- the package BANK; AMOUNT is passed to the TELLER(2) task
  127.                 -- as the amount to deposit
  128.  
  129.             Figure 2: This code segment shows that the TELLER(n) tasks are accessed like procedures.            Figure 2
  130.  
  131.                 ======================================================================
  132.  
  133.                  Each TELLER(n) task performs one of these four transactions  at  a  time.
  134.             An  external  task  calls  (makes  a  rendezvous  with,  in Ada terminology) a
  135.             TELLER(n)  task  through  its  REQUEST  entry  point,  passing  one  of  these
  136.             transaction  names  as  a parameter, and  the  TELLER(n)  task  processes  the
  137.             request.  For example, a code segment in an external  task  may look something
  138.             like Figure 2.   This code segment was extracted from the body of the CUSTOMER
  139.             task definition in the package CUSTOMER_WORLD (see later).
  140.                  This demonstration program  also  contains  several  other  tasks, called
  141.             customer  tasks.    These  tasks,  hidden inside the  package  CUSTOMER_WORLD,
  142.             operate  independently  and  interact with the  various  teller  tasks.    The
  143.             customer  tasks  make requests to the teller tasks, asking to be  added  as  a
  144.             customer of the bank, making deposits, and making withdrawals.  Using  the Ada
  145.             inter-task rendezvous mechanism to communicate,  if the teller task is already
  146.             servicing another customer task,  the  customer  task  "waits in line" (having
  147.             been placed in the  implicit  queue associated with the teller's entry point).
  148.             If queued, the customer task is serviced after the tasks in the teller's queue
  149.             in front of him have  been serviced.  Indeed, the model is similar to the real
  150.             world.
  151.                  From  the  mainline procedure, the user can  monitor  the  bank  and  its
  152.             activity.   He  can  obtain  a status report from the bank (which includes the
  153.             balanace of each  customer,  the  number  of  transactions  requested  by each
  154.             customer, and the number of transactions processed by each teller),  cause new
  155.             customer tasks  to  start  up,  and shut down the system and exit the program.
  156.  
  157.  
  158.  
  159.                                                 - 2 -
  160.  
  161.  
  162.                                 BD3 - A Demonstration of Tasking in Ada
  163.  
  164.  
  165.  
  166.             For those Ada compilers which  do  not  allow  tasking  to  proceed  while the
  167.             current task is waiting for input (such as many of the Ada compilers available
  168.             for the IBM PC), a continuous  display  function  is also provided to the user
  169.             which  displays  the  bank's status, delays five seconds (allowing the various
  170.             tasks to run),  and  displays  the  bank's  status again.  This command option
  171.             displays ten status reports before returning the user to his prompt.
  172.  
  173.  
  174.  
  175.  
  176.  
  177.  
  178.             2  Execution of the Program            2  Execution of the Program
  179.  
  180.  
  181.                  Figures 3 to 9 show various displays during the execution of the program.
  182.             These  displays were generated on a SUN workstation,  where  the  program  was
  183.             compiled by the Verdix Ada compiler.  These  displays  may  be  different from
  184.             what you see if you compile the program  on  an  IBM  PC, particularly in that
  185.             Verdix Ada does not suspend all  tasks  while  the current task is waiting for
  186.             input from the console.   While  we  are  at  the prompt in these figures, all
  187.             tasks are running in parallel with our input activity.  On some compilers this
  188.             will not be the case, and the parallel operation of the tasks will not be seen
  189.             until the user issues the 'c' (continuous bank status) command.
  190.  
  191.                 ======================================================================
  192.  
  193.             Enter
  194.               b for bank status
  195.               c for continuous bank status
  196.               s for start next customer
  197.               x for exit: b
  198.             The bank doesn't have any customers
  199.  
  200.                           Figure 3: When BD3 starts, there are no customers.                          Figure 3
  201.  
  202.                 ======================================================================
  203.  
  204.                  Figure 3 shows the menu that  is  presented  to the user when the program
  205.             starts and that no customer tasks are running yet.
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.                                                 - 3 -
  224.  
  225.  
  226.                                 BD3 - A Demonstration of Tasking in Ada
  227.  
  228.  
  229.  
  230.                 ======================================================================
  231.  
  232.             Enter
  233.               b for bank status
  234.               c for continuous bank status
  235.               s for start next customer
  236.               x for exit: s
  237.             Enter
  238.               b for bank status
  239.               c for continuous bank status
  240.               s for start next customer
  241.               x for exit: b
  242.             **** BANK STATUS REPORT ****
  243.             Customer      Balance  Transactions  Attempted_Overdraws
  244.                 1          100.00             2                    0
  245.  
  246.             Teller           :        1       2       3       4
  247.             Transaction_Count:        0       1       1       0
  248.  
  249.                         Figure 4: The 's' command starts a new customer task.                        Figure 4
  250.  
  251.                 ======================================================================
  252.  
  253.                  Figure 4 shows the start of the first customer task  via  the 's' command
  254.             followed immediately by a status report of the  bank  (requested  via  the 'b'
  255.             command).   The task we just started has had enough time between the start  of
  256.             the  task and the request of the status display to perform 2 transactions, and
  257.             we can see that tellers 2 and 3 were selected to perform these transactions.
  258.  
  259.                 ======================================================================
  260.  
  261.             Enter
  262.               b for bank status
  263.               c for continuous bank status
  264.               s for start next customer
  265.               x for exit: b
  266.             **** BANK STATUS REPORT ****
  267.             Customer      Balance  Transactions  Attempted_Overdraws
  268.                 1           95.26             3                    0
  269.  
  270.             Teller           :        1       2       3       4
  271.             Transaction_Count:        0       2       1       0
  272.  
  273.             Figure 5: Another status display shows just a little activity by the customer.            Figure 5
  274.  
  275.                 ======================================================================
  276.  
  277.                  Figure 5 shows another bank status  command,  which was issued as soon as
  278.             the display above completed.  During  this  brief amount of time, the customer
  279.             has had time to perform another transaction.
  280.  
  281.  
  282.  
  283.  
  284.  
  285.  
  286.  
  287.                                                 - 4 -
  288.  
  289.  
  290.                                 BD3 - A Demonstration of Tasking in Ada
  291.  
  292.  
  293.  
  294.                 ======================================================================
  295.  
  296.             Enter
  297.               b for bank status
  298.               c for continuous bank status
  299.               s for start next customer
  300.               x for exit: s
  301.             Enter
  302.               b for bank status
  303.               c for continuous bank status
  304.               s for start next customer
  305.               x for exit: s
  306.             Enter
  307.               b for bank status
  308.               c for continuous bank status
  309.               s for start next customer
  310.               x for exit: s
  311.             Enter
  312.               b for bank status
  313.               c for continuous bank status
  314.               s for start next customer
  315.               x for exit: s
  316.             Enter
  317.               b for bank status
  318.               c for continuous bank status
  319.               s for start next customer
  320.               x for exit: s
  321.             Enter
  322.               b for bank status
  323.               c for continuous bank status
  324.               s for start next customer
  325.               x for exit: b
  326.             **** BANK STATUS REPORT ****
  327.             Customer      Balance  Transactions  Attempted_Overdraws
  328.                 1          100.59             5                    0
  329.                 2          123.13             4                    0
  330.                 3          117.75             3                    0
  331.                 4          114.97             3                    0
  332.                 5          100.00             2                    0
  333.                 6           38.86             4                    0
  334.  
  335.             Teller           :        1       2       3       4
  336.             Transaction_Count:        5       7       7       2
  337.  
  338.                               Figure 6: Five more tasks are started up.                              Figure 6
  339.  
  340.                 ======================================================================
  341.  
  342.                  Five more customer  tasks  are  started  up  in Figure 6 and another bank
  343.             status  display  is requested.  The fact that we have many  tasks  running  in
  344.             parallel now should become evident as we see more and  more  activity going on
  345.             between each of our status displays.
  346.  
  347.  
  348.  
  349.  
  350.  
  351.                                                 - 5 -
  352.  
  353.  
  354.                                 BD3 - A Demonstration of Tasking in Ada
  355.  
  356.  
  357.  
  358.                 ======================================================================
  359.  
  360.             Enter
  361.               b for bank status
  362.               c for continuous bank status
  363.               s for start next customer
  364.               x for exit: c
  365.             **** BANK STATUS REPORT ****
  366.             Customer      Balance  Transactions  Attempted_Overdraws
  367.                 1          134.37             7                    0
  368.                 2          131.77             5                    0
  369.                 3          202.01             5                    0
  370.                 4          129.76             4                    0
  371.                 5          100.00             2                    0
  372.                 6           57.83             5                    0
  373.  
  374.             Teller           :        1       2       3       4
  375.             Transaction_Count:        9       9       7       3
  376.  
  377.                  ...
  378.  
  379.             **** BANK STATUS REPORT ****
  380.             Customer      Balance  Transactions  Attempted_Overdraws
  381.                 1           73.44            29                    3
  382.                 2          206.04            24                    0
  383.                 3          165.82            27                    0
  384.                 4           58.48            24                    3
  385.                 5           71.03            22                    0
  386.                 6           41.02            27                    2
  387.  
  388.             Teller           :        1       2       3       4
  389.             Transaction_Count:       60      36      38      19
  390.  
  391.             Figure 7: A continous bank status display shows a lot of activity over a short time.            Figure 7
  392.  
  393.                 ======================================================================
  394.  
  395.                  Figure 7 shows  a  'c'  (continue  bank status) command and its resulting
  396.             display.  To save space, I have shown only the  first  and  the  last  of  the
  397.             eleven bank status report displays generated by this command.
  398.  
  399.  
  400.  
  401.  
  402.  
  403.  
  404.  
  405.  
  406.  
  407.  
  408.  
  409.  
  410.  
  411.  
  412.  
  413.  
  414.  
  415.                                                 - 6 -
  416.  
  417.  
  418.                                 BD3 - A Demonstration of Tasking in Ada
  419.  
  420.  
  421.  
  422.                 ======================================================================
  423.  
  424.             Enter
  425.               b for bank status
  426.               c for continuous bank status
  427.               s for start next customer
  428.               x for exit: s
  429.             Enter
  430.               b for bank status
  431.               c for continuous bank status
  432.               s for start next customer
  433.               x for exit: s
  434.             Enter
  435.               b for bank status
  436.               c for continuous bank status
  437.               s for start next customer
  438.               x for exit: b
  439.             **** BANK STATUS REPORT ****
  440.             Customer      Balance  Transactions  Attempted_Overdraws
  441.                 1          108.96            31                    3
  442.                 2          226.90            26                    0
  443.                 3          106.79            30                    0
  444.                 4           87.86            26                    3
  445.                 5           57.83            24                    0
  446.                 6           23.36            30                    3
  447.                 7           50.89             3                    0
  448.                 8          100.00             2                    0
  449.  
  450.             Teller           :        1       2       3       4
  451.             Transaction_Count:       68      42      42      21
  452.  
  453.                             Figure 8: Two more customer tasks are started.                            Figure 8
  454.  
  455.                 ======================================================================
  456.  
  457.                  In Figure 8, two more customer tasks are started and the result is shown.
  458.             There are now 8 customer tasks, 4 teller tasks, and the mainline procedure (as
  459.             another task) running in this Ada system.
  460.  
  461.  
  462.  
  463.  
  464.  
  465.  
  466.  
  467.  
  468.  
  469.  
  470.  
  471.  
  472.  
  473.  
  474.  
  475.  
  476.  
  477.  
  478.  
  479.                                                 - 7 -
  480.  
  481.  
  482.                                 BD3 - A Demonstration of Tasking in Ada
  483.  
  484.  
  485.  
  486.                 ======================================================================
  487.  
  488.             Enter
  489.               b for bank status
  490.               c for continuous bank status
  491.               s for start next customer
  492.               x for exit: b
  493.             **** BANK STATUS REPORT ****
  494.             Customer      Balance  Transactions  Attempted_Overdraws
  495.                 1          127.88            34                    3
  496.                 2          232.11            28                    0
  497.                 3           56.17            33                    0
  498.                 4          110.24            28                    3
  499.                 5           81.60            28                    0
  500.                 6            4.68            32                    3
  501.                 7           31.60             6                    1
  502.                 8           54.42             4                    0
  503.  
  504.             Teller           :        1       2       3       4
  505.             Transaction_Count:       79      48      44      22
  506.             Enter
  507.               b for bank status
  508.               c for continuous bank status
  509.               s for start next customer
  510.               x for exit: b
  511.             **** BANK STATUS REPORT ****
  512.             Customer      Balance  Transactions  Attempted_Overdraws
  513.                 1           63.89            37                    3
  514.                 2          147.16            32                    0
  515.                 3           48.62            38                    0
  516.                 4          272.81            36                    3
  517.                 5           62.22            34                    0
  518.                 6           74.99            36                    4
  519.                 7           59.31            10                    1
  520.                 8           72.42             9                    0
  521.  
  522.             Teller           :        1       2       3       4
  523.             Transaction_Count:       94      59      56      24
  524.  
  525.                  Figure 9: Two more status reports are shown, each after some delay.                 Figure 9
  526.  
  527.                 ======================================================================
  528.  
  529.                  Figure 9 shows two more bank  status  displays.   The user of the program
  530.             has delayed for some time before issuing these commands so that  a significant
  531.             level of activity can be shown.
  532.                  More activity could  be  displayed,  and  more  customer  tasks  could be
  533.             started,  but the displays shown so far should be enough to give the reader  a
  534.             good feel  for  the  program's  operation.  When the user is finished, the 'x'
  535.             (for  exit)  command  will  terminate  all  tasks  and return the user to  the
  536.             operating system.
  537.                  The  displays  presented  so  far  were  generated  by the  BD3  mainline
  538.             procedure running on a UNIX system, having been  compiled  by  the  Verdix Ada
  539.             compiler.    BD3.EXE  provided in the  distribution  was  compiled  under  the
  540.  
  541.  
  542.  
  543.                                                 - 8 -
  544.  
  545.  
  546.                                 BD3 - A Demonstration of Tasking in Ada
  547.  
  548.  
  549.  
  550.             IntegrAda environment.  The  reader  will see similar displays when BD3.EXE is
  551.             executed with the exception that no  other  tasks  will run when the prompt is
  552.             displayed.  In order for multitasking to be observed when running BD3.EXE, the                        __________________________________________________________________
  553.             user  must issue the 'c' (for continuous bank status) command.  Once the delay            ______________________________________________________________
  554.             statement in the mainline is encountered, the Ada runtime system is allowed to
  555.             come into play and other tasks are then permitted to run.
  556.  
  557.  
  558.  
  559.  
  560.  
  561.  
  562.             3  Discussion of the Design            3  Discussion of the Design
  563.  
  564.  
  565.                  BD3  is an object-oriented design.  The objects  contained  in  this  Ada
  566.             system  are  a  console  device  (defined  by  the  Ada package CONSOLE) which
  567.             supports  input  and  output from and to the user's console terminal, a random
  568.             number  generator  (defined  by the Ada package RANDOM) which generates random
  569.             numbers of type  FLOAT  in the range from 0.0 to 1.0, the bank (defined by the
  570.             Ada package BANK) which contains the four TELLER(n) objects  (defined  by  the
  571.             Ada  task  type  TELLER_PERSON)  and  the  basic  type  definitions  (such  as
  572.             TRANSACTION, CUSTOMER_ID, and DOLLAR)  which  are  used  to communicate with a
  573.             TELLER(n)  object,  and the base of customers  (defined  by  the  Ada  package
  574.             CUSTOMER_WORLD) which interacts with the tellers in the bank.
  575.                  The specification to the package CONSOLE is shown in Figures 10,  11, and
  576.             12.  Each line is numbered for the convenience of the reader (of course, these
  577.             numbers do not appear in the files which are compiled by an Ada compiler).
  578.  
  579.  
  580.  
  581.  
  582.  
  583.  
  584.  
  585.  
  586.  
  587.  
  588.  
  589.  
  590.  
  591.  
  592.  
  593.  
  594.  
  595.  
  596.  
  597.  
  598.  
  599.  
  600.  
  601.  
  602.  
  603.  
  604.  
  605.  
  606.  
  607.                                                 - 9 -
  608.  
  609.  
  610.                                 BD3 - A Demonstration of Tasking in Ada
  611.  
  612.  
  613.  
  614.                 ======================================================================
  615.  
  616.               1 package CONSOLE is
  617.               2 --------------------------------------------------------------------------
  618.               3 --| BEGIN PROLOGUE
  619.               4 --| DESCRIPTION            : CONSOLE is a package which implements an
  620.               5 --|                        : abstract state machine, a console terminal,
  621.               6 --|                        : that maps to the user's terminal.  CONSOLE
  622.               7 --|                        : provides routines to output characters,
  623.               8 --|                        : strings, integers, and floats (real numbers)
  624.               9 --|                        : to the user's terminal.  CONSOLE provides
  625.              10 --|                        : a routine to input a string of text from the
  626.              11 --|                        : user's terminal.  Finally, CONSOLE provides
  627.              12 --|                        : a function which can trim leading spaces
  628.              13 --|                        : from a string of text (useful in outputting
  629.              14 --|                        : text which was input by the read routine).
  630.              15 --|                        :
  631.              16 --| REQUIREMENTS SUPPORTED : A simple I/O package for Ada programs
  632.              17 --|                        :
  633.              18 --| LIMITATIONS            : Text input by CONSOLE.READ can be no more
  634.              19 --|                        : than 80 characters long.  Only objects of
  635.              20 --|                        : type CHARACTER, STRING, INTEGER, and FLOAT
  636.              21 --|                        : can be output.
  637.              22 --|                        :
  638.              23 --| AUTHOR(S)              : Richard Conn
  639.              24 --| CHANGE LOG             : 08/30/88  RLC  Initial Design and Code
  640.              25 --|                        :
  641.              26 --| REMARKS                : None
  642.              27 --|                        :
  643.              28 --| PORTABILITY ISSUES     : Uses TEXT_IO, so is very portable; no known
  644.              29 --|                        : portability problems.
  645.              30 --| END PROLOGUE
  646.              31 --------------------------------------------------------------------------
  647.              32
  648.  
  649.                        Figure 10: Specification of Package CONSOLE, Part 1 of 4                       Figure 10
  650.  
  651.                 ======================================================================
  652.  
  653.                  In Figure 10, the prologue in the specification of the package CONSOLE is
  654.             given.  Line 1 is the only piece of processed code; the rest of the  lines are
  655.             Ada comments which describe  the  package and give other information about it.
  656.             I developed this package some time ago for use in my Ada classes, feeling that
  657.             the package TEXT_IO (which is supplied with all Ada compilers) is  too complex
  658.             for  most  beginners  to work with.  Package CONSOLE starts  to  introduce  an
  659.             object-oriented design to Ada code design and is simple to use.
  660.  
  661.  
  662.  
  663.  
  664.  
  665.  
  666.  
  667.  
  668.  
  669.  
  670.  
  671.                                                 - 10 -
  672.  
  673.  
  674.                                 BD3 - A Demonstration of Tasking in Ada
  675.  
  676.  
  677.  
  678.                 ======================================================================
  679.  
  680.              33     -- Special items to print
  681.              34     type    SPECIAL_ITEM is (NEW_LINE, TAB, BACKSPACE);
  682.              35
  683.              36     -- Type of string used by READ procedure
  684.              37     subtype OUTSTRING    is STRING(1 .. 80);
  685.              38
  686.              39     procedure WRITE(ITEM : in STRING);
  687.              40     procedure WRITE(ITEM : in CHARACTER);
  688.              41     -- Print strings and characters
  689.              42     -- Examples:
  690.              43     --  Ada procedure call                      Prints (without quotes)
  691.              44     --  ============================            =======================
  692.              45     --  CONSOLE.WRITE ("This is a test");       "This is a test"
  693.              46     --  CONSOLE.WRITE ('?');                    "?"
  694.              47
  695.              48     procedure WRITE(ITEM : in SPECIAL_ITEM);
  696.              49     -- Print special items
  697.              50     -- Example:
  698.              51     --  Ada procedure call                      Prints (without quotes)
  699.              52     --  ============================            =======================
  700.              53     --  CONSOLE.WRITE (CONSOLE.NEW_LINE);       <advances to next line>
  701.              54
  702.              55 --
  703.              56 -- Package CONSOLE
  704.              57
  705.              58     procedure WRITE(ITEM : in INTEGER; WIDTH : in NATURAL := 0);
  706.              59     -- Print integers
  707.              60     -- Examples:
  708.              61     --  Ada procedure call                      Prints (without quotes)
  709.              62     --  ============================            =======================
  710.              63     --  CONSOLE.WRITE (25);                     "25"
  711.              64     --  CONSOLE.WRITE (-3);                     "-3"
  712.              65     --  CONSOLE.WRITE (25, 5);                  "   25"
  713.              66
  714.  
  715.                        Figure 11: Specification of Package CONSOLE, Part 2 of 4                       Figure 11
  716.  
  717.                 ======================================================================
  718.  
  719.                  Figure 11 contains more of  the specification of package CONSOLE, showing
  720.             the  two  type definitions used by procedures  within  the  package  and  four
  721.             procedure  specifications,  all  for procedures named WRITE (see lines 39, 40,
  722.             48, and 58).  These procedures,  all  similarly  named, differ in the types of
  723.             arguments they accept, and Ada determines which procedure is reference  by the
  724.             types of  the  arguments  used  when  the  call to the procedure is made.  The
  725.             comment blocks in lines 41-46, 49-53, and 59-65 contain examples of  how these
  726.             procedures would be called from outside of package CONSOLE.
  727.                  Note that  the  WRITE  procedure  on  line  58 accepts two parameters, an
  728.             INTEGER and a NATURAL number with a default value.  The default value of 0 for
  729.             the  WIDTH parameter tells the procedure to use as many spaces as necessary to
  730.             output  the number.  As indicated by lines 63-65, the WIDTH parameter does not
  731.             have to be referenced when the procedure is called.
  732.  
  733.  
  734.  
  735.                                                 - 11 -
  736.  
  737.  
  738.                                 BD3 - A Demonstration of Tasking in Ada
  739.  
  740.  
  741.  
  742.                 ======================================================================
  743.  
  744.              67     procedure WRITE(ITEM           : in FLOAT;
  745.              68                     BEFORE_DECIMAL : in NATURAL := 5;
  746.              69                     AFTER_DECIMAL  : in NATURAL := 5);
  747.              70     procedure WRITE_SCIENTIFIC(ITEM          : in FLOAT;
  748.              71                                AFTER_DECIMAL : in NATURAL := 8);
  749.              72     -- Print floats
  750.              73     -- Examples:
  751.              74     --  Ada procedure call                      Prints (without quotes)
  752.              75     --  ============================            =======================
  753.              76     --  CONSOLE.WRITE (25.21);                  "   25.21000"
  754.              77     --  CONSOLE.WRITE (-36.2);                  "  -36.20000"
  755.              78     --  CONSOLE.WRITE (-36.2, 1, 1);            "-36.2"
  756.              79     --  CONSOLE.WRITE (25.21, 3);               " 25.21000"
  757.              80     --  CONSOLE.WRITE (25.21, 3, 2);            " 25.21"
  758.              81     --  CONSOLE.WRITE_SCIENTIFIC (23.0);        " 2.30000000e+01"
  759.              82     --  CONSOLE.WRITE_SCIENTIFIC (5.7, 2);      " 5.70E+00"
  760.              83     --  CONSOLE.WRITE_SCIENTIFIC (-4.5e-24, 4); "-4.5000E-24"
  761.              84
  762.  
  763.                        Figure 12: Specification of Package CONSOLE, Part 3 of 4                       Figure 12
  764.  
  765.                 ======================================================================
  766.  
  767.                  Figure  12  contains  the next part  of  the  specification  for  package
  768.             CONSOLE.  Lines  67-69  define  the  specification for a WRITE procedure which
  769.             works on  objects  of  type  FLOAT (floating point) to output them in the form
  770.             "nn.nn"  while lines 70-71 define the  specification  for  a  WRITE_SCIENTIFIC
  771.             procedure which also works on  objects  of  type  FLOAT  but  outputs  them in
  772.             scientific notation.
  773.  
  774.  
  775.  
  776.  
  777.  
  778.  
  779.  
  780.  
  781.  
  782.  
  783.  
  784.  
  785.  
  786.  
  787.  
  788.  
  789.  
  790.  
  791.  
  792.  
  793.  
  794.  
  795.  
  796.  
  797.  
  798.  
  799.                                                 - 12 -
  800.  
  801.  
  802.                                 BD3 - A Demonstration of Tasking in Ada
  803.  
  804.  
  805.  
  806.                 ======================================================================
  807.  
  808.              85     procedure READ(ITEM : out OUTSTRING);
  809.              86     -- Read strings
  810.              87     -- Example (note: <CR> refers to the RETURN key):
  811.              88     --  MY_STRING : CONSOLE.OUTSTRING; -- 80-char string
  812.              89     --  Ada procedure call              User Types      In MY_STRING
  813.              90     --  ====================            ==========      ============
  814.              91     --  CONSOLE.READ (MY_STRING);       "Hi<CR>"        "Hi"<and 78 spaces>
  815.              92
  816.              93     function TRIM(ITEM : in STRING) return STRING;
  817.              94     -- Generate a string which has no trailing spaces
  818.              95     -- Example of use:
  819.              96     --  MY_STRING : CONSOLE.OUTSTRING;
  820.              97     --  CONSOLE.READ(MY_STRING);
  821.              98     --  CONSOLE.WRITE("Hello, ");
  822.              99     --  CONSOLE.WRITE(CONSOLE.TRIM(MY_STRING));
  823.             100     --  CONSOLE.WRITE(", how are you?");
  824.             101     -- If the CONSOLE.READ statement returns "Joe" followed by 77 spaces,
  825.             102     -- the output will look like "Hello, Joe, how are you?"
  826.             103
  827.             104 end CONSOLE;
  828.  
  829.                        Figure 13: Specification of Package CONSOLE, Part 4 of 4                       Figure 13
  830.  
  831.                 ======================================================================
  832.  
  833.                  Figure 13 shows the last part of package CONSOLE.  Procedure READ on line
  834.             85  always  returns  an object of type OUTSTRING, which is 80 characters long.
  835.             When this procedure is called, the  next  line  typed by the user is returned.
  836.             If it is less than 80 characters long, trailing spaces are appended to it.  If
  837.             it is more than 80 characters long, the first 80  characters  are returned and
  838.             the next call  to  READ returns the next 80.  For the convenience of the user,
  839.             the  function TRIM (line 93) is provided to convert a string of any length  to
  840.             one of another length that contains all characters of the input  string except
  841.             the trailing spaces.
  842.  
  843.                 ======================================================================
  844.  
  845.               MY_NUMBER : FLOAT; -- variable definition
  846.               ...
  847.               MY_NUMBER := RANDOM.NUMBER; -- compute the next random number
  848.  
  849.                             Figure 14: Calling the Random Number Generator                            Figure 14
  850.  
  851.                 ======================================================================
  852.  
  853.                  The  random  number  generator object used by the Bank Demo Ada system is
  854.             defined by the Ada package named RANDOM.  Figure 15 contains the specification
  855.             of this  package.    RANDOM  contains  only  one function, named NUMBER, which
  856.             requires no input parameters and returns  the  next random number as an object
  857.             of type FLOAT.  A code segment like the one  in  Figure 14 is used to call the
  858.             NUMBER function in package RANDOM:
  859.  
  860.  
  861.  
  862.  
  863.                                                 - 13 -
  864.  
  865.  
  866.                                 BD3 - A Demonstration of Tasking in Ada
  867.  
  868.  
  869.  
  870.                 ======================================================================
  871.  
  872.               1 package RANDOM is
  873.               2 --------------------------------------------------------------------------
  874.               3 --| BEGIN PROLOGUE
  875.               4 --| DESCRIPTION            : Package RANDOM contains the function NUMBER
  876.               5 --|                        : which returns a pseudo-random number
  877.               6 --|                        : of type FLOAT in the range 0.0 .. 1.0.
  878.               7 --|                        :
  879.               8 --| REQUIREMENTS SUPPORTED : Random Number Generator
  880.               9 --|                        :
  881.              10 --| LIMITATIONS            : None
  882.              11 --|                        :
  883.              12 --| AUTHOR(S)              : Richard Conn (RLC) from Bill Whitaker's work
  884.              13 --| CHANGE LOG             : 09/30/88  RLC  Design, code, test from
  885.              14 --|                        :                 Bill Whitaker's original work
  886.              15 --|                        : 10/11/88  RLC  Modified based on ideas from
  887.              16 --|                        :                 Ron Bell and his RAN2 Package
  888.              17 --|                        :
  889.              18 --| REMARKS                : None
  890.              19 --|                        :
  891.              20 --| PORTABILITY ISSUES     : Uses 16-bit integers, so should be quite
  892.              21 --|                        : portable
  893.              22 --| END PROLOGUE
  894.              23 --------------------------------------------------------------------------
  895.              24
  896.              25     function NUMBER return FLOAT;
  897.              26     -- Return a floating point pseudo-random number
  898.              27
  899.              28 end RANDOM;
  900.  
  901.                               Figure 15: Specification of Package RANDOM                              Figure 15
  902.  
  903.                 ======================================================================
  904.  
  905.                  If you look at the body of  package  RANDOM,  which  is  included  in the
  906.             source code distributed with Bank Demo,  you  will find that RANDOM contains a
  907.             hidden procedure called SEED that sets the first random number in the sequence
  908.             based  on the time-of-day clock value returned  by  the  Ada-standard  package
  909.             called CALENDAR.  Procedure SEED, however, is not needed by the outside world,
  910.             so package RANDOM does not make it available.
  911.  
  912.  
  913.  
  914.  
  915.  
  916.  
  917.  
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927.                                                 - 14 -
  928.  
  929.  
  930.                                 BD3 - A Demonstration of Tasking in Ada
  931.  
  932.  
  933.  
  934.                 ======================================================================
  935.  
  936.               1 package BANK is
  937.               2 --------------------------------------------------------------------------
  938.               3 --| BEGIN PROLOGUE
  939.               4 --| DESCRIPTION            : BANK defines a bank, the TELLER objects
  940.               5 --|                        : within it, and the procedure PRINT_REPORT
  941.               6 --|                        : (which reports on the status of the BANK).
  942.               7 --|                        :
  943.               8 --|                        : BANK is an abstract state machine, defining
  944.               9 --|                        : a BANK object which contains TELLER objects.
  945.              10 --|                        :
  946.              11 --| REQUIREMENTS SUPPORTED : Bank Demonstration Program to show
  947.              12 --|                        : object-oriented design and tasking
  948.              13 --|                        : with Ada
  949.              14 --|                        :
  950.              15 --| LIMITATIONS            : None
  951.              16 --| AUTHOR(S)              : Richard Conn (RLC)
  952.              17 --| CHANGE LOG             : 1/16/89  RLC  Initial Design and Code
  953.              18 --| CHANGE LOG             : 2/25/89  RLC  Final Review Prior to Release
  954.              19 --| REMARKS                : None
  955.              20 --| PORTABILITY ISSUES     : None
  956.              21 --| END PROLOGUE
  957.              22 --------------------------------------------------------------------------
  958.              23
  959.  
  960.                         Figure 16: Specification of Package BANK, Part 1 of 4                        Figure 16
  961.  
  962.                 ======================================================================
  963.  
  964.                  Figure 16 contains the  prologue  of  the  specification of package BANK,
  965.             which defines the bank object.  Note that the tellers are implemented as tasks
  966.             (I refer to the tellers in a general sense as  TELLER(n), where n is 1 to 4 to
  967.             indicate which teller).
  968.  
  969.                 ======================================================================
  970.  
  971.              24     -- TRANSACTION requested of a TELLER
  972.              25     type TRANSACTION  is (ADD_NEW_CUSTOMER,
  973.              26                           GET_BALANCE,
  974.              27                           MAKE_DEPOSIT,
  975.              28                           MAKE_WITHDRAWAL);
  976.              29
  977.              30     -- Unit of currency
  978.              31     type DOLLAR       is new FLOAT;
  979.              32
  980.              33     -- Identification of a CUSTOMER
  981.              34     type CUSTOMER_ID  is new NATURAL range 1 .. NATURAL'LAST;
  982.              35
  983.  
  984.                         Figure 17: Specification of Package BANK, Part 2 of 4                        Figure 17
  985.  
  986.                 ======================================================================
  987.  
  988.  
  989.  
  990.  
  991.                                                 - 15 -
  992.  
  993.  
  994.                                 BD3 - A Demonstration of Tasking in Ada
  995.  
  996.  
  997.  
  998.                  Figure 17 shows  more  of  the  specification  of package BANK.  The type
  999.             definitions are presented first.  Lines 25-28 define  type  TRANSACTION, which
  1000.             are the transactions which may  be  requested  of  a  TELLER(n)  object.   The
  1001.             transactions  which  may  be  performed  by  a  teller  are  ADD_NEW_CUSTOMER,
  1002.             GET_BALANCE, MAKE_DEPOSIT,  and MAKE_WITHDRAWAL.  Line 31 defines type DOLLAR,
  1003.             which  is  the  unit  of  currency for the bank.  DOLLAR is implemented  as  a
  1004.             floating point number, derived from type FLOAT, but DOLLAR objects  are unique
  1005.             from FLOAT objects by this type definition (DOLLAR is a  derived  type in Ada)
  1006.             and we cannot interchange the use of a DOLLAR object and a FLOAT object.  Line
  1007.             34 defines  type  CUSTOMER_ID,  which  is  the  ID number associated with each
  1008.             customer.  When a transaction is made with a teller, the customer presents his
  1009.             ID  number  to identify himself along with  his  transaction  request.    Like
  1010.             DOLLAR, CUSTOMER_ID is a derived type, but CUSTOMER_ID is  derived  from  type
  1011.             NATURAL  and  can  take on values from 1 to NATURAL'LAST  (the  largest  value
  1012.             allowed for objects of type NATURAL).
  1013.  
  1014.                 ======================================================================
  1015.  
  1016.              36     -- Index of and Number of TELLER objects within the bank
  1017.              37     type TELLER_INDEX is new NATURAL range 1 .. 4;
  1018.              38
  1019.              39     -- A TELLER_PERSON is an object to which a CUSTOMER may make a REQUEST
  1020.              40     -- The BANK tells the TELLER_PERSON to START_WORK, giving the
  1021.              41     -- TELLER_PERSON its TELLER_NUMBER
  1022.              42     task type TELLER_PERSON is
  1023.              43         entry REQUEST(ID     : in out CUSTOMER_ID;
  1024.              44                       KIND   : in TRANSACTION;
  1025.              45                       AMOUNT : in out DOLLAR);
  1026.              46     end TELLER_PERSON;
  1027.              47     -- These are the TELLER objects available at the bank
  1028.              48     TELLER : array(TELLER_INDEX) of TELLER_PERSON;
  1029.              49
  1030.  
  1031.                         Figure 18: Specification of Package BANK, Part 3 of 4                        Figure 18
  1032.  
  1033.                 ======================================================================
  1034.  
  1035.                  In  Figure  18,  line  37  defines  type  TELLER_INDEX,  which is used to
  1036.             identify the desired teller.    Type TELLER_INDEX is derived from type NATURAL
  1037.             and restricted in range from 1 to 4.    If  the  user  wishes  to  modify this
  1038.             program and add  more  tellers to the model, he need only change the 4 on line
  1039.             37 to the desired number.  The parts of the code which need to  know  how many
  1040.             tellers  are  available  at the bank reference TELLER_INDEX'LAST, which is the
  1041.             largest value that objects of type TELLER_INDEX can take on.
  1042.                  Task type TELLER_PERSON on lines 42-46 defines the interface to all tasks
  1043.             of type TELLER_PERSON.  A TELLER_PERSON task contains one entry  point, called
  1044.             REQUEST,  which  can  be  called  by  tasks  external to package BANK.   Three
  1045.             parameters must be specified when the REQUEST entry point is called: the ID of
  1046.             the customer (type  CUSTOMER_ID),  the KIND of transaction (type TRANSACTION),
  1047.             and the AMOUNT associated with the transaction (type DOLLAR).
  1048.                  The task body of  TELLER_PERSON  is not contained in the specification of
  1049.             package BANK, but it is hidden in the body of package BANK.  You can  see this
  1050.             code  by looking at the source code provided in the distribution.  In summary,
  1051.             tasks  of type TELLER_PERSON are quite simple in their operation.  When a task
  1052.  
  1053.  
  1054.  
  1055.                                                 - 16 -
  1056.  
  1057.  
  1058.                                 BD3 - A Demonstration of Tasking in Ada
  1059.  
  1060.  
  1061.  
  1062.             of   type  TELLER_PERSON  starts  running,  it   calls   the   internal   task
  1063.             TELLER_ASSIGNER (which is hidden inside of  package  BANK) in order to get its
  1064.             ID number.  As each customer has an ID, so  each  teller  also has an ID.  The
  1065.             teller's ID  is  used  to  keep a running record of the number of transactions
  1066.             each teller makes.  After it gets it's ID number, a task of type TELLER_PERSON
  1067.             enters an infinite loop in which it waits  for  an  external  task to call its
  1068.             REQUEST entry point, processes the request from this external  task  based  on
  1069.             the  KIND of transaction requested, and then resumes the loop.  It is left  as
  1070.             an exercise to the reader to read the code and figure out exactly what happens
  1071.             for each KIND of transaction.
  1072.                  Line 48 defines the array, named  TELLER,  of  tellers in the bank.  Each
  1073.             element  of  this  array  is  of  type  TELLER_PERSON,  making each element an
  1074.             independent task  as  opposed  to  what the reader may normally think of as an
  1075.             array (which is an array of values stored  in  memory).    The array TELLER is
  1076.             indexed  by  TELLER_INDEX, taking on index values from 1 to 4.    Hence,  four
  1077.             tasks are created by  the  array declaration on line 48: TELLER(1), TELLER(2),
  1078.             TELLER(3), and TELLER(4).  Each task starts running  during  initialization of
  1079.             the Ada system  before the first line  of  code  of  the mainline procedure is
  1080.             executed.
  1081.  
  1082.                 ======================================================================
  1083.  
  1084.              50     -- PRINT_REPORT gives the transaction log of all the bank
  1085.              51     -- customers
  1086.              52     procedure PRINT_REPORT;
  1087.              53
  1088.              54     -- STOP_WORK terminates all TELLER tasks
  1089.              55     procedure STOP_WORK;
  1090.              56 end BANK;
  1091.  
  1092.                         Figure 19: Specification of Package BANK, Part 4 of 4                        Figure 19
  1093.  
  1094.                 ======================================================================
  1095.  
  1096.                  Package  BANK  also  exports  two  procedures,  as  shown in  Figure  19:
  1097.             PRINT_REPORT and STOP_WORK.  PRINT_REPORT  (whose specification is on line 52)
  1098.             prints  a report of the status of the bank.  This report indicates the  number
  1099.             of transactions requested by  each  customer,  the  balance of each customer's
  1100.             account, and the number of transactions processed by each teller.  These items
  1101.             of information are updated constantly by the TELLER(n)  tasks  by  means  of a
  1102.             data  base kept internal to package BANK.  The outside world does not need  to
  1103.             know  that this data base exists or what form it exists in; the outside  world
  1104.             only  needs to know that it can print this report based on information in  the
  1105.             data base.  PRINT_REPORT is called by the BD3 mainline procedure  whenever the
  1106.             user at the console asks for it or during the running of the continuous status
  1107.             display command issued by the user.  STOP_WORK (whose specification is on line
  1108.             55) terminates  all  of  the  TELLER(n) tasks.  STOP_WORK is called by the BD3
  1109.             mainline procedure when the user asks for the program to  shut  down (the exit
  1110.             command).   All tasks of the Ada system must be terminated before the mainline
  1111.             procedure,  which  is also a task, may  terminate.    STOP_WORK  represents  a
  1112.             function that would be performed by a bank when it closes and it is reasonable
  1113.             to provide it as part of the  specification  of  package  BANK  as  opposed to
  1114.             relying  upon the mainline procedure to abort each of the TELLER(n) tasks on a
  1115.             task-by-task basis.
  1116.  
  1117.  
  1118.  
  1119.                                                 - 17 -
  1120.  
  1121.  
  1122.                                 BD3 - A Demonstration of Tasking in Ada
  1123.  
  1124.  
  1125.  
  1126.                 ======================================================================
  1127.  
  1128.             282 package CUSTOMER_WORLD is
  1129.             283 --------------------------------------------------------------------------
  1130.             284 --| BEGIN PROLOGUE
  1131.             285 --| DESCRIPTION            : CUSTOMER_WORLD is an abstract state machine
  1132.             286 --|                        : which defines the collection of all CUSTOMERs
  1133.             287 --|                        : of the BANK.  It allows the mainline procedure
  1134.             288 --|                        : to ADD a new CUSTOMER and TERMINATE_ALL
  1135.             289 --|                        : current CUSTOMERs.  The CUSTOMER itself acts
  1136.             290 --|                        : as an independent task and requires no
  1137.             291 --|                        : direct interaction with the mainline once
  1138.             292 --|                        : it starts.
  1139.             293 --|                        :
  1140.             294 --| REQUIREMENTS SUPPORTED : Bank Demonstration Program to show
  1141.             295 --|                        : object-oriented design and tasking
  1142.             296 --|                        : with Ada
  1143.             297 --|                        :
  1144.             298 --| LIMITATIONS            : None
  1145.             299 --| AUTHOR(S)              : Richard Conn (RLC)
  1146.             300 --| CHANGE LOG             : 1/16/89  RLC  Initial Design and Code
  1147.             301 --| CHANGE LOG             : 2/25/89  RLC  Final Review Prior to Release
  1148.             302 --| REMARKS                : None
  1149.             303 --| PORTABILITY ISSUES     : None
  1150.             304 --| END PROLOGUE
  1151.             305 --------------------------------------------------------------------------
  1152.             306
  1153.             307     -- Add another CUSTOMER task to the system
  1154.             308     procedure ADD;
  1155.             309
  1156.             310     -- Terminate all CUSTOMERs in the system
  1157.             311     procedure TERMINATE_ALL;
  1158.             312
  1159.             313 end CUSTOMER_WORLD;
  1160.  
  1161.                           Figure 20: Specification of Package CUSTOMER_WORLD                          Figure 20
  1162.  
  1163.                 ======================================================================
  1164.  
  1165.                  Figure 20 contains the specification of the package CUSTOMER_WORLD.  This
  1166.             package  contains,  hidden within it, all of  the  customer  tasks  which  are
  1167.             running  in the system.  Internally, package  CUSTOMER_WORLD  keeps  track  of
  1168.             these tasks  by  creating  a  linked  list  which points to each of them.  The
  1169.             procedure  ADD  (whose  specification  is  on  line  308) causes  the  package
  1170.             CUSTOMER_WORLD to spawn another customer task, updating the  linked  list when
  1171.             it  does  so.    When  each  customer  task  is  spawned,  it  begins  running
  1172.             immediately, performing the functions of an independent customer.    There are
  1173.             no entry points  to a customer; the outside world does not request access to a
  1174.             customer,  and  the  customer tasks each  act  independently  of  each  other,
  1175.             requesting access to the  TELLER(n)  tasks in the bank to perform transactions
  1176.             as they need them.  Each time the user issues the "start new customer" command
  1177.             from  the  console,  procedure CUSTOMER_WORLD.ADD is called  to  perform  this
  1178.             function, and a new customer task starts running.
  1179.  
  1180.  
  1181.  
  1182.  
  1183.                                                 - 18 -
  1184.  
  1185.  
  1186.                                 BD3 - A Demonstration of Tasking in Ada
  1187.  
  1188.  
  1189.  
  1190.                  As mentioned in the  discussion  of package BANK, all children tasks have
  1191.             to  be  aborted  before the mainline  procedure  can  terminate,  and  package
  1192.             CUSTOMER_WORLD exports  the procedure TERMINATE_ALL to do this.  TERMINATE_ALL
  1193.             moves  through  the  linked  list  of  tasks,  aborting  each  one  as  it  is
  1194.             encountered.  The BD3  mainline  procedure  calls CUSTOMER_WORLD.TERMINATE_ALL
  1195.             just like it calls BANK.STOP_WORK when the exit command is processed.
  1196.                  The task specification and body of a customer  (the  task  type  is named
  1197.             CUSTOMER) is hidden in the body of package CUSTOMER_WORLD.  Each customer task
  1198.             performs the following sequence of operations:
  1199.  
  1200.               1. The customer selects a TELLER(n)  task  at random using the random number
  1201.             generator  (function  NUMBER  in package RANDOM).    The  customer  issues  an
  1202.             ADD_NEW_CUSTOMER transaction through  the  REQUEST entry point of the selected
  1203.             TELLER(n) task.  The selected TELLER(n) task returns the  customer  task's  ID
  1204.             number, which the customer task stores for use on all future transactions with
  1205.             all TELLER(n) tasks.
  1206.               2.  The  customer,  using his ID number, then selects a  TELLER(n)  task  at
  1207.             random and issues a MAKE_DEPOSIT  transaction  through  that  teller's REQUEST
  1208.             entry  point.  The customer deposits $100.00 (see lines 325 and 379-380 in the
  1209.             full listing of BD3 distributed with this document).
  1210.               3. The customer  now enters an infinite loop, which he stays in for the rest
  1211.             of his life  (until  he is aborted by the user at the console issuing the exit
  1212.             command).  This loop (see lines 389-399 of the source listing) consists of the
  1213.             following steps:
  1214.               3.1.  Delay a random amount of time from 0 to 5 seconds.
  1215.               3.2.  Generate a random  amount  of  money  from  -$50.00 to $50.00.  If the
  1216.             amount is negative, select the current transaction to  be  MAKE_WITHDRAWAL and
  1217.             make  the  amount  positive.  If the amount is positive,  select  the  current
  1218.             transaction to be MAKE_DEPOSIT.
  1219.               3.3.    Select  a TELLER(n) task at random, call that teller's REQUEST entry
  1220.             point,  passing  to  it the his ID number, the desired  transaction,  and  the
  1221.             amount.   The TELLER(n) task will then process  the  transaction,  allowing  a
  1222.             withdrawal only if the customer has sufficient funds to cover the request.
  1223.  
  1224.                  Figures  21  to  24 contain the source code of the mainline procedure for
  1225.             this Ada  system,  procedure  BD3  (short for Bank Demo 3).  This procedure is
  1226.             where the execution of the mainline begins.   All  tasks  which  were declared
  1227.             statically as objects, such as the TELLER(n) tasks of package BANK,  will have
  1228.             already been initialized  and  begun  execution  before the first line of this
  1229.             procedure is executed.  The customer tasks will be dynamically  created during
  1230.             the execution of this procedure, where a new  customer  task  will  be created
  1231.             each time the user issues the "start next customer" command from the console.
  1232.  
  1233.  
  1234.  
  1235.  
  1236.  
  1237.  
  1238.  
  1239.  
  1240.  
  1241.  
  1242.  
  1243.  
  1244.  
  1245.  
  1246.  
  1247.                                                 - 19 -
  1248.  
  1249.  
  1250.                                 BD3 - A Demonstration of Tasking in Ada
  1251.  
  1252.  
  1253.  
  1254.                 ======================================================================
  1255.  
  1256.             442 with BANK;
  1257.             443 with CUSTOMER_WORLD;
  1258.             444 with CONSOLE;
  1259.             445 procedure BD3 is                           -- BANK_DEMO_3
  1260.             446 ------------------------------------------------------------------------
  1261.             447 --| BEGIN PROLOGUE
  1262.             448 --| DESCRIPTION            : Procedure BD3 (BANK DEMO 3) is a mainline
  1263.             449 --|                        : which demonstrates the operation of the
  1264.             450 --|                        : BANK.  Upon invocation, the console becomes
  1265.             451 --|                        : a command processor for the bank manager.
  1266.             452 --|                        : The bank manager can obtain the status of
  1267.             453 --|                        : the bank (balances, number of transactions,
  1268.             454 --|                        : and attempted overdraws of all customers
  1269.             455 --|                        : and number of transactions processed by all
  1270.             456 --|                        : tellers) in a single or continuous (group
  1271.             457 --|                        : of 11 over about one minute) display.
  1272.             458 --|                        : The user at the console can also cause new
  1273.             459 --|                        : Customer tasks to be created and shut down
  1274.             460 --|                        : the system.
  1275.             461 --|                        :
  1276.             462 --| REQUIREMENTS SUPPORTED : Bank Demonstration Program to show
  1277.             463 --|                        : object-oriented design and tasking
  1278.             464 --|                        : with Ada
  1279.             465 --|                        :
  1280.             466 --| LIMITATIONS            : None
  1281.             467 --| AUTHOR(S)              : Richard Conn (RLC)
  1282.             468 --| CHANGE LOG             : 1/16/89  RLC  Initial Design and Code
  1283.             469 --| CHANGE LOG             : 2/25/89  RLC  Final Review Prior to Release
  1284.             470 --| REMARKS                : None
  1285.             471 --| PORTABILITY ISSUES     : Uses CONSOLE (TEXT_IO), so is very portable;
  1286.             472 --|                        : no known portability problems.
  1287.             473 --| END PROLOGUE
  1288.             474 ------------------------------------------------------------------------
  1289.             475
  1290.  
  1291.                                 Figure 21: Procedure BD3, Part 1 of 4                                Figure 21
  1292.  
  1293.                 ======================================================================
  1294.  
  1295.                  In Figure 21, lines 442-444 establish the context in which  the procedure
  1296.             functions.  In particular, the procedure BD3 needs to know about package BANK,
  1297.             package  CUSTOMER_WORLD,  and  package  CONSOLE.   These Ada packages must  be
  1298.             previously compiled into the current program unit library before procedure BD3
  1299.             can  be  compiled.   The Ada compiler  will  check  all  interfaces  (such  as
  1300.             procedure and object names, parameters passed to the procedures, and the types
  1301.             of all objects referenced) between these packages and procedure BD3  each time
  1302.             BD3 references one of these packages.
  1303.                  Line  445  introduces  the procedure (is the beginning of procedure BD3's
  1304.             body), and the rest of the lines in Figure 21 are comments in the prologue.
  1305.  
  1306.  
  1307.  
  1308.  
  1309.  
  1310.  
  1311.                                                 - 20 -
  1312.  
  1313.  
  1314.                                 BD3 - A Demonstration of Tasking in Ada
  1315.  
  1316.  
  1317.  
  1318.                 ======================================================================
  1319.  
  1320.             476     -- Line input from the console
  1321.             477     INPUT                               : CONSOLE.OUTSTRING;
  1322.             478
  1323.             479     -- Number of continuous status reports displayed by the 'c'
  1324.             480     -- command before control is returned to the console
  1325.             481     NUMBER_OF_CONTINUOUS_STATUS_REPORTS : constant := 10;
  1326.             482
  1327.  
  1328.                                 Figure 22: Procedure BD3, Part 2 of 4                                Figure 22
  1329.  
  1330.                 ======================================================================
  1331.  
  1332.                  Figure 22 shows a local variable  and  a local constant in procedure BD3.
  1333.             The variable INPUT is used  to receive the line entered by the user when he is
  1334.             prompted for input.  The READ  procedure  in  package CONSOLE is used to input
  1335.             this line.  The definition of the constant number of continuous status reports
  1336.             is self-explanatory.
  1337.  
  1338.                 ======================================================================
  1339.  
  1340.             483 --
  1341.             484 -- procedure BD3
  1342.             485
  1343.             486 begin                                      -- mainline
  1344.             487
  1345.             488     -- This is the beginning of the main loop.  In this loop,
  1346.             489     -- a list of commands is printed on the console, the user
  1347.             490     -- at the console (as CUSTOMER 0) enters one of these commands
  1348.             491     -- followed by striking the RETURN key, and the command is
  1349.             492     -- processed.
  1350.             493     loop
  1351.             494
  1352.             495         -- Command listing and prompt
  1353.             496     CONSOLE.WRITE("Enter");
  1354.             497     CONSOLE.WRITE(CONSOLE.NEW_LINE);
  1355.             498     CONSOLE.WRITE("  b for bank status");
  1356.             499     CONSOLE.WRITE(CONSOLE.NEW_LINE);
  1357.             500     CONSOLE.WRITE("  c for continuous bank status");
  1358.             501     CONSOLE.WRITE(CONSOLE.NEW_LINE);
  1359.             502     CONSOLE.WRITE("  s for start next customer");
  1360.             503     CONSOLE.WRITE(CONSOLE.NEW_LINE);
  1361.             504     CONSOLE.WRITE("  x for exit: ");
  1362.             505     CONSOLE.READ(INPUT);
  1363.             506
  1364.  
  1365.                                 Figure 23: Procedure BD3, Part 3 of 4                                Figure 23
  1366.  
  1367.                 ======================================================================
  1368.  
  1369.                  Figure 23 shows the beginning of the executable code  in  procedure  BD3.
  1370.             This  code starts after the "begin" statement on line 486, and the entirety of
  1371.             this code is contained within the loop which starts on line 493.
  1372.  
  1373.  
  1374.  
  1375.                                                 - 21 -
  1376.  
  1377.  
  1378.                                 BD3 - A Demonstration of Tasking in Ada
  1379.  
  1380.  
  1381.  
  1382.                  The first thing done in this  loop  is  the presentation of the prompt to
  1383.             the  user  (lines 496-504) and the input of the command from  the  user  (line
  1384.             505).
  1385.  
  1386.                 ======================================================================
  1387.  
  1388.             507         -- Interpretation and execution of input command
  1389.             508     case INPUT(1) is
  1390.             509         when 'b' | 'c' =>              -- Short or continuous bank status
  1391.             510                                        -- report
  1392.             511         BANK.PRINT_REPORT;
  1393.             512         if INPUT(1) = 'c' then
  1394.             513             for I in 1 .. NUMBER_OF_CONTINUOUS_STATUS_REPORTS loop
  1395.             514             delay 5.0;
  1396.             515             BANK.PRINT_REPORT;
  1397.             516                     CONSOLE.WRITE(CONSOLE.NEW_LINE);
  1398.             517             end loop;
  1399.             518         end if;
  1400.             519
  1401.             520         when 's' =>                    -- Start up a new CUSTOMER
  1402.             521         CUSTOMER_WORLD.ADD;
  1403.             522
  1404.             523         when 'x' =>                      -- Exit program
  1405.             524         CUSTOMER_WORLD.TERMINATE_ALL;    -- Kill CUSTOMER tasks
  1406.             525         BANK.STOP_WORK;                  -- Kill TELLER tasks
  1407.             526         exit;                            -- Exit loop
  1408.             527
  1409.             528         when ' ' =>                    -- Non-error on a null input line
  1410.             529         null;
  1411.             530
  1412.             531         when others =>                 -- Other commands are invalid
  1413.             532         CONSOLE.WRITE("Invalid Command: ");
  1414.             533         CONSOLE.WRITE(CONSOLE.TRIM(INPUT));
  1415.             534         CONSOLE.WRITE(CONSOLE.NEW_LINE);
  1416.             535
  1417.             536     end case;
  1418.             537
  1419.             538     end loop;
  1420.             539
  1421.             540 end BD3;
  1422.  
  1423.                                 Figure 24: Procedure BD3, Part 4 of 4                                Figure 24
  1424.  
  1425.                 ======================================================================
  1426.  
  1427.                  Figure 24 shows the rest of procedure  BD3.    The  first  letter  of the
  1428.             command  just  input  (line 505 of Figure 23)  is  the  target  for  the  case
  1429.             expression  in line 508.  If this letter is a lower-case 'b' (bank status)  or
  1430.             'c'  (continuous bank status), the code in lines 509-519 will be executed.  If
  1431.             this  letter  is  a lower-case 's' (start next customer), the  code  in  lines
  1432.             520-522 will be executed.  If this letter is a lower-case 'x' (exit), the code
  1433.             in lines 523-527 will be executed.  If this letter is a space, nothing happens
  1434.             (lines 528-530).  If this letter is anything else, an error message is printed
  1435.  
  1436.  
  1437.  
  1438.  
  1439.                                                 - 22 -
  1440.  
  1441.  
  1442.                                 BD3 - A Demonstration of Tasking in Ada
  1443.  
  1444.  
  1445.  
  1446.             (lines 531-535).    The  loop  itself ends on lines 538, and the procedure BD3
  1447.             ends on line 540.
  1448.  
  1449.  
  1450.  
  1451.  
  1452.  
  1453.  
  1454.             4  File Distribution            4  File Distribution
  1455.  
  1456.  
  1457.                  Figure  25  shows  the files provided in the distribution of Bank Demo 3.
  1458.             This document is in one-column format in the file PRINT.ME.
  1459.  
  1460.                 ======================================================================
  1461.  
  1462.                  READ.ME          An introduction to the distribution
  1463.                  PRINT.ME         This document, ready to be printed as ASCII
  1464.                                     text on 8 1/2" x 11" paper in elite type
  1465.                  BD3.SPR          Source (in Borland's SPRINT) to the file PRINT.ME
  1466.  
  1467.                  CONSOLE.ADA      Compilable Ada source code to package CONSOLE
  1468.                  RANDOM.ADA       Compilable Ada source code to package RANDOM
  1469.                  BD3.ADA          Compilable Ada source code to packages BANK
  1470.                                     and CUSTOMER_WORLD and procedure BD3
  1471.                                   Note: the compilation order is CONSOLE.ADA,
  1472.                                     RANDOM.ADA, and BD3.ADA
  1473.  
  1474.                  CONSOLE.LST      Listing of CONSOLE.ADA with each line numbered
  1475.                  RANDOM.LST       Listing of RANDOM.ADA with each line numbered
  1476.                  BD3.LST          Listing of BD3.ADA with each line numbered
  1477.  
  1478.                  BD3.EXE          Executable binary of the BD3 system (run by
  1479.                                     giving the command "BD3" at the MSDOS prompt)
  1480.  
  1481.                          Figure 25: Files Distributed as Part of Bank Demo 3                         Figure 25
  1482.  
  1483.                 ======================================================================
  1484.  
  1485.  
  1486.  
  1487.  
  1488.  
  1489.  
  1490.  
  1491.  
  1492.  
  1493.  
  1494.  
  1495.  
  1496.  
  1497.  
  1498.  
  1499.  
  1500.  
  1501.  
  1502.  
  1503.                                                 - 23 -
  1504.  
  1505.  
  1506.  
  1507.  
  1508.  
  1509.  
  1510.  
  1511.  
  1512.  
  1513.  
  1514.  
  1515.  
  1516.                                             ContentsContents
  1517.  
  1518.  
  1519.                      1  Introduction . . . . . . . . . . . . . . . . . . . . . . . 1
  1520.                      2  Execution of the Program . . . . . . . . . . . . . . . . . 3
  1521.                      3  Discussion of the Design . . . . . . . . . . . . . . . . . 9
  1522.                      4  File Distribution  . . . . . . . . . . . . . . . . . . .  23
  1523.  
  1524.  
  1525.  
  1526.  
  1527.  
  1528.  
  1529.  
  1530.  
  1531.  
  1532.  
  1533.  
  1534.  
  1535.  
  1536.  
  1537.  
  1538.  
  1539.  
  1540.  
  1541.  
  1542.  
  1543.  
  1544.  
  1545.  
  1546.  
  1547.  
  1548.  
  1549.  
  1550.  
  1551.  
  1552.  
  1553.  
  1554.  
  1555.  
  1556.  
  1557.  
  1558.  
  1559.  
  1560.  
  1561.  
  1562.  
  1563.  
  1564.  
  1565.  
  1566.  
  1567.                                                   i
  1568.  
  1569.  
  1570.  
  1571.  
  1572.  
  1573.  
  1574.  
  1575.  
  1576.  
  1577.  
  1578.  
  1579.  
  1580.  
  1581.  
  1582.  
  1583.  
  1584.  
  1585.  
  1586.  
  1587.  
  1588.  
  1589.  
  1590.  
  1591.  
  1592.  
  1593.  
  1594.  
  1595.  
  1596.  
  1597.  
  1598.  
  1599.  
  1600.  
  1601.  
  1602.  
  1603.  
  1604.  
  1605.  
  1606.  
  1607.  
  1608.  
  1609.  
  1610.  
  1611.  
  1612.  
  1613.  
  1614.  
  1615.  
  1616.  
  1617.  
  1618.  
  1619.  
  1620.  
  1621.  
  1622.  
  1623.  
  1624.  
  1625.  
  1626.  
  1627.  
  1628.  
  1629.  
  1630.  
  1631.                                                   ii
  1632.  
  1633.  
  1634.  
  1635.  
  1636.  
  1637.  
  1638.  
  1639.  
  1640.  
  1641.  
  1642.  
  1643.  
  1644.                                             FiguresFigures
  1645.  
  1646.  
  1647.                   Figure 1: The bank tellers can process four kinds of
  1648.                             transactions.  . . . . . . . . . . . . . . . . . . . . 1
  1649.                   Figure 2: This code segment shows that the TELLER(n) tasks are
  1650.                             accessed like procedures.  . . . . . . . . . . . . . . 2
  1651.                   Figure 3: When BD3 starts, there are no customers. . . . . . . . 3
  1652.                   Figure 4: The 's' command starts a new customer task.  . . . . . 4
  1653.                   Figure 5: Another status display shows just a little activity by
  1654.                             the customer.  . . . . . . . . . . . . . . . . . . . . 4
  1655.                   Figure 6: Five more tasks are started up.  . . . . . . . . . . . 5
  1656.                   Figure 7: A continous bank status display shows a lot of activity
  1657.                             over a short time. . . . . . . . . . . . . . . . . . . 6
  1658.                   Figure 8: Two more customer tasks are started. . . . . . . . . . 7
  1659.                   Figure 9: Two more status reports are shown, each after some
  1660.                             delay. . . . . . . . . . . . . . . . . . . . . . . . . 8
  1661.                   Figure 10: Specification of Package CONSOLE, Part 1 of 4 . . . .10
  1662.                   Figure 11: Specification of Package CONSOLE, Part 2 of 4 . . . .11
  1663.                   Figure 12: Specification of Package CONSOLE, Part 3 of 4 . . . .12
  1664.                   Figure 13: Specification of Package CONSOLE, Part 4 of 4 . . . .13
  1665.                   Figure 14: Calling the Random Number Generator . . . . . . . . .13
  1666.                   Figure 15: Specification of Package RANDOM . . . . . . . . . . .14
  1667.                   Figure 16: Specification of Package BANK, Part 1 of 4  . . . . .15
  1668.                   Figure 17: Specification of Package BANK, Part 2 of 4  . . . . .15
  1669.                   Figure 18: Specification of Package BANK, Part 3 of 4  . . . . .16
  1670.                   Figure 19: Specification of Package BANK, Part 4 of 4  . . . . .17
  1671.                   Figure 20: Specification of Package CUSTOMER_WORLD . . . . . . .18
  1672.                   Figure 21: Procedure BD3, Part 1 of 4  . . . . . . . . . . . . .20
  1673.                   Figure 22: Procedure BD3, Part 2 of 4  . . . . . . . . . . . . .21
  1674.                   Figure 23: Procedure BD3, Part 3 of 4  . . . . . . . . . . . . .21
  1675.                   Figure 24: Procedure BD3, Part 4 of 4  . . . . . . . . . . . . .22
  1676.                   Figure 25: Files Distributed as Part of Bank Demo 3  . . . . . .23
  1677.  
  1678.  
  1679.  
  1680.  
  1681.  
  1682.  
  1683.  
  1684.  
  1685.  
  1686.  
  1687.  
  1688.  
  1689.  
  1690.  
  1691.  
  1692.  
  1693.  
  1694.  
  1695.                                                  iii
  1696.